{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4e0f5da1",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Image features exercise\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "We have seen that we can achieve reasonable performance on an image classification task by training a linear classifier on the pixels of the input image. In this exercise we will show that we can improve our classification performance by training linear classifiers not on raw pixels but on features that are computed from the raw pixels.\n",
    "\n",
    "All of your work for this exercise will be done in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0d58276c",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97a87599",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "## Load data\n",
    "Similar to previous exercises, we will load CIFAR-10 data from disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a592ccc4",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "from cs231n.features import color_histogram_hsv, hog_feature\n",
    "\n",
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = '../Dataset/CIFAR10'\n",
    "\n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # Subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test\n",
    "\n",
    "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c760961",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "## Extract Features\n",
    "For each image we will compute a Histogram of Oriented\n",
    "Gradients (HOG) as well as a color histogram using the hue channel in HSV\n",
    "color space. We form our final feature vector for each image by concatenating\n",
    "the HOG and color histogram feature vectors.\n",
    "\n",
    "Roughly speaking, HOG should capture the texture of the image while ignoring\n",
    "color information, and the color histogram represents the color of the input\n",
    "image while ignoring texture. As a result, we expect that using both together\n",
    "ought to work better than using either alone. Verifying this assumption would\n",
    "be a good thing to try for your own interest.\n",
    "\n",
    "The `hog_feature` and `color_histogram_hsv` functions both operate on a single\n",
    "image and return a feature vector for that image. The extract_features\n",
    "function takes a set of images and a list of feature functions and evaluates\n",
    "each feature function on each image, storing the results in a matrix where\n",
    "each column is the concatenation of all feature vectors for a single image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f203c89d",
   "metadata": {
    "scrolled": true,
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done extracting features for 1000 / 49000 images\n",
      "Done extracting features for 2000 / 49000 images\n",
      "Done extracting features for 3000 / 49000 images\n",
      "Done extracting features for 4000 / 49000 images\n",
      "Done extracting features for 5000 / 49000 images\n",
      "Done extracting features for 6000 / 49000 images\n",
      "Done extracting features for 7000 / 49000 images\n",
      "Done extracting features for 8000 / 49000 images\n",
      "Done extracting features for 9000 / 49000 images\n",
      "Done extracting features for 10000 / 49000 images\n",
      "Done extracting features for 11000 / 49000 images\n",
      "Done extracting features for 12000 / 49000 images\n",
      "Done extracting features for 13000 / 49000 images\n",
      "Done extracting features for 14000 / 49000 images\n",
      "Done extracting features for 15000 / 49000 images\n",
      "Done extracting features for 16000 / 49000 images\n",
      "Done extracting features for 17000 / 49000 images\n",
      "Done extracting features for 18000 / 49000 images\n",
      "Done extracting features for 19000 / 49000 images\n",
      "Done extracting features for 20000 / 49000 images\n",
      "Done extracting features for 21000 / 49000 images\n",
      "Done extracting features for 22000 / 49000 images\n",
      "Done extracting features for 23000 / 49000 images\n",
      "Done extracting features for 24000 / 49000 images\n",
      "Done extracting features for 25000 / 49000 images\n",
      "Done extracting features for 26000 / 49000 images\n",
      "Done extracting features for 27000 / 49000 images\n",
      "Done extracting features for 28000 / 49000 images\n",
      "Done extracting features for 29000 / 49000 images\n",
      "Done extracting features for 30000 / 49000 images\n",
      "Done extracting features for 31000 / 49000 images\n",
      "Done extracting features for 32000 / 49000 images\n",
      "Done extracting features for 33000 / 49000 images\n",
      "Done extracting features for 34000 / 49000 images\n",
      "Done extracting features for 35000 / 49000 images\n",
      "Done extracting features for 36000 / 49000 images\n",
      "Done extracting features for 37000 / 49000 images\n",
      "Done extracting features for 38000 / 49000 images\n",
      "Done extracting features for 39000 / 49000 images\n",
      "Done extracting features for 40000 / 49000 images\n",
      "Done extracting features for 41000 / 49000 images\n",
      "Done extracting features for 42000 / 49000 images\n",
      "Done extracting features for 43000 / 49000 images\n",
      "Done extracting features for 44000 / 49000 images\n",
      "Done extracting features for 45000 / 49000 images\n",
      "Done extracting features for 46000 / 49000 images\n",
      "Done extracting features for 47000 / 49000 images\n",
      "Done extracting features for 48000 / 49000 images\n",
      "Done extracting features for 49000 / 49000 images\n"
     ]
    }
   ],
   "source": [
    "from cs231n.features import *\n",
    "\n",
    "num_color_bins = 10 # Number of bins in the color histogram\n",
    "feature_fns = [hog_feature, lambda img: color_histogram_hsv(img, nbin=num_color_bins)]\n",
    "X_train_feats = extract_features(X_train, feature_fns, verbose=True)\n",
    "X_val_feats = extract_features(X_val, feature_fns)\n",
    "X_test_feats = extract_features(X_test, feature_fns)\n",
    "\n",
    "# Preprocessing: Subtract the mean feature\n",
    "mean_feat = np.mean(X_train_feats, axis=0, keepdims=True)\n",
    "X_train_feats -= mean_feat\n",
    "X_val_feats -= mean_feat\n",
    "X_test_feats -= mean_feat\n",
    "\n",
    "# Preprocessing: Divide by standard deviation. This ensures that each feature\n",
    "# has roughly the same scale.\n",
    "std_feat = np.std(X_train_feats, axis=0, keepdims=True)\n",
    "X_train_feats /= std_feat\n",
    "X_val_feats /= std_feat\n",
    "X_test_feats /= std_feat\n",
    "\n",
    "# Preprocessing: Add a bias dimension\n",
    "X_train_feats = np.hstack([X_train_feats, np.ones((X_train_feats.shape[0], 1))])\n",
    "X_val_feats = np.hstack([X_val_feats, np.ones((X_val_feats.shape[0], 1))])\n",
    "X_test_feats = np.hstack([X_test_feats, np.ones((X_test_feats.shape[0], 1))])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22b500b5",
   "metadata": {},
   "source": [
    "## Train SVM on features\n",
    "Using the multiclass SVM code developed earlier in the assignment, train SVMs on top of the features extracted above; this should achieve better results than training SVMs directly on top of raw pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c8e82b89",
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 89.973569\n",
      "iteration 100 / 1500: loss 9.000000\n",
      "iteration 200 / 1500: loss 9.000000\n",
      "iteration 300 / 1500: loss 9.000000\n",
      "iteration 400 / 1500: loss 9.000000\n",
      "iteration 500 / 1500: loss 9.000000\n",
      "iteration 600 / 1500: loss 9.000000\n",
      "iteration 700 / 1500: loss 9.000000\n",
      "iteration 800 / 1500: loss 9.000000\n",
      "iteration 900 / 1500: loss 9.000000\n",
      "iteration 1000 / 1500: loss 9.000000\n",
      "iteration 1100 / 1500: loss 9.000000\n",
      "iteration 1200 / 1500: loss 9.000000\n",
      "iteration 1300 / 1500: loss 9.000000\n",
      "iteration 1400 / 1500: loss 9.000000\n",
      "iteration 0 / 1500: loss 777.289023\n",
      "iteration 100 / 1500: loss 9.000000\n",
      "iteration 200 / 1500: loss 9.000000\n",
      "iteration 300 / 1500: loss 9.000000\n",
      "iteration 400 / 1500: loss 9.000000\n",
      "iteration 500 / 1500: loss 9.000000\n",
      "iteration 600 / 1500: loss 9.000000\n",
      "iteration 700 / 1500: loss 9.000000\n",
      "iteration 800 / 1500: loss 9.000000\n",
      "iteration 900 / 1500: loss 9.000000\n",
      "iteration 1000 / 1500: loss 9.000000\n",
      "iteration 1100 / 1500: loss 9.000000\n",
      "iteration 1200 / 1500: loss 9.000000\n",
      "iteration 1300 / 1500: loss 9.000000\n",
      "iteration 1400 / 1500: loss 9.000000\n",
      "iteration 0 / 1500: loss 8038.769254\n",
      "iteration 100 / 1500: loss 9.000000\n",
      "iteration 200 / 1500: loss 9.000000\n",
      "iteration 300 / 1500: loss 9.000000\n",
      "iteration 400 / 1500: loss 9.000000\n",
      "iteration 500 / 1500: loss 9.000000\n",
      "iteration 600 / 1500: loss 9.000000\n",
      "iteration 700 / 1500: loss 9.000000\n",
      "iteration 800 / 1500: loss 9.000000\n",
      "iteration 900 / 1500: loss 9.000000\n",
      "iteration 1000 / 1500: loss 9.000000\n",
      "iteration 1100 / 1500: loss 9.000000\n",
      "iteration 1200 / 1500: loss 9.000000\n",
      "iteration 1300 / 1500: loss 9.000000\n",
      "iteration 1400 / 1500: loss 9.000000\n",
      "iteration 0 / 1500: loss 83.247982\n",
      "iteration 100 / 1500: loss 8.999999\n",
      "iteration 200 / 1500: loss 8.999999\n",
      "iteration 300 / 1500: loss 8.999999\n",
      "iteration 400 / 1500: loss 8.999999\n",
      "iteration 500 / 1500: loss 8.999999\n",
      "iteration 600 / 1500: loss 8.999999\n",
      "iteration 700 / 1500: loss 8.999999\n",
      "iteration 800 / 1500: loss 8.999999\n",
      "iteration 900 / 1500: loss 8.999999\n",
      "iteration 1000 / 1500: loss 8.999999\n",
      "iteration 1100 / 1500: loss 8.999999\n",
      "iteration 1200 / 1500: loss 8.999999\n",
      "iteration 1300 / 1500: loss 8.999999\n",
      "iteration 1400 / 1500: loss 8.999999\n",
      "iteration 0 / 1500: loss 805.558299\n",
      "iteration 100 / 1500: loss 8.999999\n",
      "iteration 200 / 1500: loss 8.999999\n",
      "iteration 300 / 1500: loss 8.999999\n",
      "iteration 400 / 1500: loss 8.999999\n",
      "iteration 500 / 1500: loss 8.999999\n",
      "iteration 600 / 1500: loss 8.999999\n",
      "iteration 700 / 1500: loss 8.999999\n",
      "iteration 800 / 1500: loss 8.999999\n",
      "iteration 900 / 1500: loss 8.999999\n",
      "iteration 1000 / 1500: loss 8.999999\n",
      "iteration 1100 / 1500: loss 8.999999\n",
      "iteration 1200 / 1500: loss 8.999999\n",
      "iteration 1300 / 1500: loss 8.999999\n",
      "iteration 1400 / 1500: loss 8.999999\n",
      "iteration 0 / 1500: loss 7731.723098\n",
      "iteration 100 / 1500: loss 8.999999\n",
      "iteration 200 / 1500: loss 8.999999\n",
      "iteration 300 / 1500: loss 8.999999\n",
      "iteration 400 / 1500: loss 8.999999\n",
      "iteration 500 / 1500: loss 8.999999\n",
      "iteration 600 / 1500: loss 8.999999\n",
      "iteration 700 / 1500: loss 8.999999\n",
      "iteration 800 / 1500: loss 8.999999\n",
      "iteration 900 / 1500: loss 8.999999\n",
      "iteration 1000 / 1500: loss 8.999999\n",
      "iteration 1100 / 1500: loss 8.999999\n",
      "iteration 1200 / 1500: loss 8.999999\n",
      "iteration 1300 / 1500: loss 8.999999\n",
      "iteration 1400 / 1500: loss 8.999999\n",
      "iteration 0 / 1500: loss 88.441650\n",
      "iteration 100 / 1500: loss 8.999993\n",
      "iteration 200 / 1500: loss 8.999991\n",
      "iteration 300 / 1500: loss 8.999994\n",
      "iteration 400 / 1500: loss 8.999993\n",
      "iteration 500 / 1500: loss 8.999994\n",
      "iteration 600 / 1500: loss 8.999993\n",
      "iteration 700 / 1500: loss 8.999994\n",
      "iteration 800 / 1500: loss 8.999994\n",
      "iteration 900 / 1500: loss 8.999992\n",
      "iteration 1000 / 1500: loss 8.999994\n",
      "iteration 1100 / 1500: loss 8.999992\n",
      "iteration 1200 / 1500: loss 8.999993\n",
      "iteration 1300 / 1500: loss 8.999993\n",
      "iteration 1400 / 1500: loss 8.999993\n",
      "iteration 0 / 1500: loss 799.450728\n",
      "iteration 100 / 1500: loss 8.999995\n",
      "iteration 200 / 1500: loss 8.999994\n",
      "iteration 300 / 1500: loss 8.999992\n",
      "iteration 400 / 1500: loss 8.999994\n",
      "iteration 500 / 1500: loss 8.999994\n",
      "iteration 600 / 1500: loss 8.999993\n",
      "iteration 700 / 1500: loss 8.999993\n",
      "iteration 800 / 1500: loss 8.999993\n",
      "iteration 900 / 1500: loss 8.999994\n",
      "iteration 1000 / 1500: loss 8.999994\n",
      "iteration 1100 / 1500: loss 8.999994\n",
      "iteration 1200 / 1500: loss 8.999993\n",
      "iteration 1300 / 1500: loss 8.999996\n",
      "iteration 1400 / 1500: loss 8.999994\n",
      "iteration 0 / 1500: loss 7580.140409\n",
      "iteration 100 / 1500: loss 7580.109433\n",
      "iteration 200 / 1500: loss 7580.063745\n",
      "iteration 300 / 1500: loss 7580.068117\n",
      "iteration 400 / 1500: loss 7580.066164\n",
      "iteration 500 / 1500: loss 7580.033423\n",
      "iteration 600 / 1500: loss 7580.057436\n",
      "iteration 700 / 1500: loss 7580.025725\n",
      "iteration 800 / 1500: loss 7580.053095\n",
      "iteration 900 / 1500: loss 7580.082087\n",
      "iteration 1000 / 1500: loss 7580.099536\n",
      "iteration 1100 / 1500: loss 7580.051443\n",
      "iteration 1200 / 1500: loss 7580.089541\n",
      "iteration 1300 / 1500: loss 7580.100839\n",
      "iteration 1400 / 1500: loss 7580.212040\n",
      "lr 1.000000e-09 reg 5.000000e+04 train accuracy: 0.329265 val accuracy: 0.338000\n",
      "lr 1.000000e-09 reg 5.000000e+05 train accuracy: 0.329857 val accuracy: 0.316000\n",
      "lr 1.000000e-09 reg 5.000000e+06 train accuracy: 0.312592 val accuracy: 0.304000\n",
      "lr 1.000000e-08 reg 5.000000e+04 train accuracy: 0.294000 val accuracy: 0.290000\n",
      "lr 1.000000e-08 reg 5.000000e+05 train accuracy: 0.289816 val accuracy: 0.272000\n",
      "lr 1.000000e-08 reg 5.000000e+06 train accuracy: 0.328184 val accuracy: 0.348000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.303918 val accuracy: 0.318000\n",
      "lr 1.000000e-07 reg 5.000000e+05 train accuracy: 0.315980 val accuracy: 0.329000\n",
      "lr 1.000000e-07 reg 5.000000e+06 train accuracy: 0.074653 val accuracy: 0.072000\n",
      "best validation accuracy achieved: 0.348000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune the learning rate and regularization strength\n",
    "\n",
    "from cs231n.classifiers.linear_classifier import LinearSVM\n",
    "\n",
    "learning_rates = [1e-9, 1e-8, 1e-7]\n",
    "regularization_strengths = [5e4, 5e5, 5e6]\n",
    "\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_svm = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained classifer in best_svm. You might also want to play          #\n",
    "# with different numbers of bins in the color histogram. If you are careful    #\n",
    "# you should be able to get accuracy of near 0.44 on the validation set.       #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for rs in regularization_strengths:\n",
    "        svm = LinearSVM()\n",
    "        loss_hist = svm.train(X_train_feats, y_train, learning_rate=lr, reg=rs,\n",
    "                      num_iters=1500, verbose=True)\n",
    "        y_train_pred = svm.predict(X_train_feats)\n",
    "        train_acc = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = svm.predict(X_val_feats)\n",
    "        val_acc = np.mean(y_val == y_val_pred)\n",
    "        \n",
    "        results[(lr, rs)] = (train_acc, val_acc)\n",
    "        \n",
    "        if val_acc > best_val:\n",
    "            best_val = val_acc\n",
    "            best_svm = svm\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ae0dfeb4",
   "metadata": {
    "test": "svm_test_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.347\n"
     ]
    }
   ],
   "source": [
    "# Evaluate your trained SVM on the test set: you should be able to get at least 0.40\n",
    "y_test_pred = best_svm.predict(X_test_feats)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print(test_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7b0d6ff4",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Cannot take a larger sample than population when 'replace=False'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_2956\\551825935.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcls_name\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m     \u001b[0midxs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwhere\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_test\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m&\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0my_test_pred\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m     \u001b[0midxs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mchoice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0midxs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mexamples_per_class\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreplace\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     12\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0midx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0midxs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m         \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mexamples_per_class\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mcls\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mmtrand.pyx\u001b[0m in \u001b[0;36mnumpy.random.mtrand.RandomState.choice\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Cannot take a larger sample than population when 'replace=False'"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 40 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# An important way to gain intuition about how an algorithm works is to\n",
    "# visualize the mistakes that it makes. In this visualization, we show examples\n",
    "# of images that are misclassified by our current system. The first column\n",
    "# shows images that our system labeled as \"plane\" but whose true label is\n",
    "# something other than \"plane\".\n",
    "\n",
    "examples_per_class = 8\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for cls, cls_name in enumerate(classes):\n",
    "    idxs = np.where((y_test != cls) & (y_test_pred == cls))[0]\n",
    "    idxs = np.random.choice(idxs, examples_per_class, replace=False)\n",
    "    for i, idx in enumerate(idxs):\n",
    "        plt.subplot(examples_per_class, len(classes), i * len(classes) + cls + 1)\n",
    "        plt.imshow(X_test[idx].astype('uint8'))\n",
    "        plt.axis('off')\n",
    "        if i == 0:\n",
    "            plt.title(cls_name)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3074f9c",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "### Inline question 1:\n",
    "Describe the misclassification results that you see. Do they make sense?\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58626625",
   "metadata": {},
   "source": [
    "## Neural Network on image features\n",
    "Earlier in this assigment we saw that training a two-layer neural network on raw pixels achieved better classification performance than linear classifiers on raw pixels. In this notebook we have seen that linear classifiers on image features outperform linear classifiers on raw pixels. \n",
    "\n",
    "For completeness, we should also try training a neural network on image features. This approach should outperform all previous approaches: you should easily be able to achieve over 55% classification accuracy on the test set; our best model achieves about 60% classification accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eae029bf",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# Preprocessing: Remove the bias dimension\n",
    "# Make sure to run this cell only ONCE\n",
    "print(X_train_feats.shape)\n",
    "X_train_feats = X_train_feats[:, :-1]\n",
    "X_val_feats = X_val_feats[:, :-1]\n",
    "X_test_feats = X_test_feats[:, :-1]\n",
    "\n",
    "print(X_train_feats.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d2cd5c1",
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [],
   "source": [
    "from cs231n.classifiers.fc_net import TwoLayerNet\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "input_dim = X_train_feats.shape[1]\n",
    "hidden_dim = 500\n",
    "num_classes = 10\n",
    "\n",
    "data = {\n",
    "    'X_train': X_train_feats, \n",
    "    'y_train': y_train, \n",
    "    'X_val': X_val_feats, \n",
    "    'y_val': y_val, \n",
    "    'X_test': X_test_feats, \n",
    "    'y_test': y_test, \n",
    "}\n",
    "\n",
    "net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n",
    "best_net = None\n",
    "\n",
    "################################################################################\n",
    "# TODO: Train a two-layer neural network on image features. You may want to    #\n",
    "# cross-validate various parameters as in previous sections. Store your best   #\n",
    "# model in the best_net variable.                                              #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0d9fb0d",
   "metadata": {
    "test": "nn_test_accuracy"
   },
   "outputs": [],
   "source": [
    "# Run your best neural net classifier on the test set. You should be able\n",
    "# to get more than 55% accuracy.\n",
    "\n",
    "y_test_pred = np.argmax(best_net.loss(data['X_test']), axis=1)\n",
    "test_acc = (y_test_pred == data['y_test']).mean()\n",
    "print(test_acc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
